// ConfigFile.cpp

#include "ConfigFile.h"

using std::string;

ConfigFile::ConfigFile(string filename, string delimiter,
        string comment, string sentry, string sectionBeg, string sectionEnd)
: myDelimiter(delimiter), myComment(comment), mySentry(sentry),
mySectionBeg(sectionBeg), mySectionEnd(sectionEnd) {
    // Construct a ConfigFile, getting keys and values from given file

    std::ifstream in(filename.c_str());

    if (!in) throw file_not_found(filename);

    in >> (*this);
}

ConfigFile::ConfigFile()
: myDelimiter(string(1, '=')), myComment(string(1, '#')) {
    // Construct a ConfigFile without a file; empty
}

void ConfigFile::remove(const string& key) {
    keyExists(key, "");
}

void ConfigFile::remove(const string& key, const string& section) {
    // Remove key and its value
    CFileRecord record = CFileRecord(key, section);
    myContents.erase(myContents.find(record));
    return;
}

bool ConfigFile::keyExists(const string& key) const {
    return keyExists(key, "");
}

bool ConfigFile::keyExists(const string& key, const string& section) const {
    // Indicate whether key is found
    CFileRecord record = CFileRecord(key, section);
    mapci p = myContents.find(record);
    return ( p != myContents.end());
}

/* static */
void ConfigFile::trim(string& s) {
    // Remove leading and trailing whitespace
    static const char whitespace[] = " \n\t\v\r\f";
    s.erase(0, s.find_first_not_of(whitespace));
    s.erase(s.find_last_not_of(whitespace) + 1U);
}

std::ostream & operator<<(std::ostream& os, const ConfigFile& cf) {
    // Save a ConfigFile to os
    string section = "";
    for (ConfigFile::mapci p = cf.myContents.begin(); p != cf.myContents.end(); ++p) {

        if (strcmp(p->first.section.c_str(), section.c_str()) != 0) {
            if (section.length() > 0) {
                os << cf.mySectionBeg << "/" << section << cf.mySectionEnd << std::endl;
            }
            section = p->first.section;
            os << cf.mySectionBeg << section << cf.mySectionEnd << std::endl;
        }

        
        os << p->first.name << " " << cf.myDelimiter << " " << p->second << std::endl;

    }
    if (section.length() > 0) {
        os << cf.mySectionBeg << "/" << section << cf.mySectionEnd << std::endl;
    }
    return os;
}

std::istream & operator>>(std::istream& is, ConfigFile& cf) {
    // Load a ConfigFile from is
    // Read in keys and values, keeping internal whitespace
    typedef string::size_type pos;
    const string& delim = cf.myDelimiter; // separator
    const string& comm = cf.myComment; // comment
    const string& sentry = cf.mySentry; // end of file sentry
    const string& sectionBeg = cf.mySectionBeg; // beginning of section
    const string& sectionEnd = cf.mySectionEnd; // beginning of section
    const pos skip = delim.length(); // length of separator

    string nextline = ""; // might need to read ahead to see where value ends
    string section = "";

    while (is || nextline.length() > 0) {
        // Read an entire line at a time
        string line;
        if (nextline.length() > 0) {
            line = nextline; // we read ahead; use it now
            nextline = "";
        } else {
            std::getline(is, line);
        }

        // Ignore comments
        line = line.substr(0, line.find(comm));

        // Check for end of file sentry
        if (sentry != "" && line.find(sentry) != string::npos) return is;

        // Parse the line if it contains a delimiter
        pos delimPos = line.find(delim);

        //Check for new section
        pos secBeg = line.find("<");
        pos secEnd = line.find(">");
        if (secBeg < secEnd && secEnd < delimPos) {
            string name = line.substr(secBeg + 1, secEnd - secBeg - 1);
            line = "";
            if (name.find(" ") == string::npos) {
                if ((strcmp(name.substr(0, 1).c_str(), "/") == 0) && (strcmp(name.substr(1, name.length()).c_str(), section.c_str()) == 0)) {
                    section = "";
                } else if ((section.length() == 0) && (strcmp(name.substr(0, 1).c_str(), "/") != 0)) {
                    section = name;
                }
            }
        }

        if (delimPos < string::npos) {
            // Extract the key
            string key = line.substr(0, delimPos);
            line.replace(0, delimPos + skip, "");

            // See if value continues on the next line
            // Stop at blank line, next line with a key, end of stream,
            // or end of file sentry
            bool terminate = false;
            while (!terminate && is) {
                std::getline(is, nextline);
                terminate = true;

                string nlcopy = nextline;
                ConfigFile::trim(nlcopy);
                if (nlcopy == "") continue;

                nextline = nextline.substr(0, nextline.find(comm));
                if (nextline.find(delim) != string::npos)
                    continue;
                if (sentry != "" && nextline.find(sentry) != string::npos)
                    continue;

                pos secBeg = nextline.find(sectionBeg);
                pos secEnd = nextline.find(sectionEnd);
                if (secBeg < secEnd && secEnd != string::npos) {
                    continue;
                }

                nlcopy = nextline;
                ConfigFile::trim(nlcopy);
                if (nlcopy != "") line += "\n";
                line += nextline;
                terminate = false;
            }

            // Store key and value
            ConfigFile::trim(key);
            ConfigFile::trim(line);
            CFileRecord record = CFileRecord(key, section);
            cf.myContents[record] = line; // overwrites if key is repeated

        }
    }

    return is;
}